package ma.xin.shi.common;

import ma.xin.shi.AutorsarCommonUtils;

public class MydataTypeInterface {
	// 枚举示例：基础类型
    public enum enumTest {
    	enum1, enum2, enum3
    }

    /**
     * 将字符串转换为boolean值
     * 支持"true"（不区分大小写）转换为true，其他字符串（包括"false"）转换为false
     * @param str 输入的字符串（可为null，null将返回false）
     * @return 转换后的boolean值
     */
    public static boolean stringToBoolean(String str) {
        // 处理null情况，返回false
        if (str == null) {
            return false;
        }
        // 忽略大小写判断是否为"true"
        return "true".equalsIgnoreCase(str.trim());
    }

    /**
     * 将boolean值转换为字符串
     * true转换为"true"，false转换为"false"
     * @param value 输入的boolean值
     * @return 转换后的字符串（"true"或"false"）
     */
    public static String booleanToString(boolean value) {
        return value ? "true" : "false";
    }

    /**
     * 安全将字符串转换为Integer（针对swMaxTextSz等需trim且可能为null的场景）
     * @param str 待转换的字符串（如swMaxTextSz，可能为null、空字符串、空白字符串）
     * @param defaultValue 当字符串为null/空/非数字时，返回的默认值（需符合业务逻辑，如ARXML规范默认值255）
     * @return 转换后的Integer（非null）
     * @throws IllegalArgumentException 若默认值为负数（不符合“最大长度”等非负业务场景）
     */
    public static Integer safeStringToInt(String str, Integer defaultValue) {
        // 1. 校验默认值合法性（针对“最大长度”等业务场景，默认值不能为负）
        if (defaultValue < 0) {
            throw new IllegalArgumentException("默认值不能为负数：" + defaultValue 
                + "（适用于swMaxTextSz等非负业务场景）");
        }
        // 2. 处理null：直接返回默认值
        if (str == null) {
            return defaultValue;
        }
        // 3. 安全执行trim：避免空指针（str已非null，可安全调用trim()）
        String trimmedStr = str.trim();
        // 4. 处理trim后为空字符串的场景
        if (trimmedStr.isEmpty()) {
            return defaultValue;
        }
        // 5. 尝试转换：处理非数字格式的异常
        try {
            int result = Integer.parseInt(trimmedStr);
            // 6. 业务校验：确保转换结果非负（如swMaxTextSz表示“最大长度”，不能为负）
            return result >= 0 ? result : defaultValue;
        } catch (NumberFormatException e) {
            // 非数字格式时，返回默认值并记录日志（便于追溯ARXML字段异常）
        	AutorsarCommonUtils.logEx("字符串转整数失败（非数字格式），使用默认值：" 
                + "输入字符串=" + str + "，默认值=" + defaultValue + "，异常信息：" + e.getMessage());
            return defaultValue;
        }
    }

    /**
     * 整数转字符串的安全处理方法（与safeStringToInt配套使用）
     * @param number 待转换的整数（可能为null）
     * @param defaultStr 当number为null时返回的默认字符串（如ARXML解析场景的默认值"255"）
     * @return 转换后的字符串（非null）
     */
    public static String safeIntToString(Integer number, String defaultStr) {
        // 1. 处理null值：返回默认字符串（确保默认值非null，避免后续使用时出现空指针）
        if (number == null) {
            // 对默认字符串做null防护，兜底返回空字符串（极端情况保障）
            return defaultStr != null ? defaultStr : "";
        }
        // 2. 非null整数直接转换为字符串
        return String.valueOf(number);
    }

    /**
     * 安全对比两个字符串是否完全相同（包括null场景处理）
     * @param str1 第一个字符串（可能为null）
     * @param str2 第二个字符串（可能为null）
     * @return 两个字符串是否完全相同（true表示相同，false表示不同）
     *         特殊场景：两个都为null时返回true，其中一个为null时返回false
     */
    public static boolean isStringEqual(String str1, String str2) {
        // 处理两个都为null的情况
        if (str1 == null && str2 == null) {
            return true;
        }
        // 处理其中一个为null的情况
        if (str1 == null || str2 == null) {
            return false;
        }
        // 两个都非null时，使用equals进行值比较
        return str1.equals(str2);
    }

    /**
     * 安全对比两个字符串是否完全相同（忽略大小写，包括null场景处理）
     * @param str1 第一个字符串（可能为null）
     * @param str2 第二个字符串（可能为null）
     * @return 两个字符串是否忽略大小写后完全相同
     */
    public static boolean isStringEqualIgnoreCase(String str1, String str2) {
        // 处理两个都为null的情况
        if (str1 == null && str2 == null) {
            return true;
        }
        // 处理其中一个为null的情况
        if (str1 == null || str2 == null) {
            return false;
        }
        // 两个都非null时，使用equalsIgnoreCase忽略大小写比较
        return str1.equalsIgnoreCase(str2);
    }

    /**
     * 对比两个字符串的相同长度部分是否相同（按较短字符串长度计算）
     * @param str1 第一个字符串（可能为null）
     * @param str2 第二个字符串（可能为null）
     * @return 按较短长度截取后的子串是否完全相同
     *         特殊场景：任一为null时返回false，均为null时返回true，空字符串按正常逻辑对比
     */
    public static boolean isStringPartialEqual(String str1, String str2) {
        // 处理null场景
        if (str1 == null && str2 == null) {
            return true;
        }
        if (str1 == null || str2 == null) {
            return false;
        }

        // 计算对比长度（取较短字符串的长度）
        int compareLength = Math.min(str1.length(), str2.length());

        // 若对比长度为0（两个都是空字符串）
        if (compareLength == 0) {
            return true;
        }

        // 截取子串并对比
        String subStr1 = str1.substring(0, compareLength);
        String subStr2 = str2.substring(0, compareLength);
        return subStr1.equals(subStr2);
    }

    /**
     * 对比两个字符串的相同长度部分是否相同（按较短字符串长度计算，忽略大小写）
     * @param str1 第一个字符串（可能为null）
     * @param str2 第二个字符串（可能为null）
     * @return 按较短长度截取后的子串是否忽略大小写后相同
     */
    public static boolean isStringPartialEqualIgnoreCase(String str1, String str2) {
        // 处理null场景
        if (str1 == null && str2 == null) {
            return true;
        }
        if (str1 == null || str2 == null) {
            return false;
        }

        // 计算对比长度（取较短字符串的长度）
        int compareLength = Math.min(str1.length(), str2.length());

        // 若对比长度为0（两个都是空字符串）
        if (compareLength == 0) {
            return true;
        }

        // 截取子串并忽略大小写对比
        String subStr1 = str1.substring(0, compareLength);
        String subStr2 = str2.substring(0, compareLength);
        return subStr1.equalsIgnoreCase(subStr2);
    }
    
    /**
     * 将数字字符串转换为对应的十进制整数
     * @param numberStr 数字字符串（可能为十六进制或十进制）
     *                  十六进制格式：以0x开头（如0x1A、0xff）
     *                  十进制格式：不含0x前缀（如123、-45）
     * @return 转换后的十进制整数
     * @throws NumberFormatException 如果字符串格式不符合要求或超出int范围
     */
    public static int parseStringToInt(String numberStr) {
        // 处理null情况
        if (numberStr == null) {
            throw new NumberFormatException("输入字符串不能为null");
        }
        
        // 去除首尾空白字符
        String trimmedStr = numberStr.trim();
        if (trimmedStr.isEmpty()) {
            throw new NumberFormatException("输入字符串不能为空");
        }
        
        // 判断是否为十六进制（0x开头，且后面至少有一个有效字符）
        if (trimmedStr.startsWith("0x") || trimmedStr.startsWith("0X")) {
            if (trimmedStr.length() <= 2) {
                throw new NumberFormatException("无效的十六进制字符串：" + numberStr);
            }
            // 截取0x后面的部分，使用16进制解析
            return Integer.parseInt(trimmedStr.substring(2), 16);
        } else {
            // 否则按十进制解析
            return Integer.parseInt(trimmedStr, 10);
        }
    }

    /**
     * 将数字转换为指定总长度的十六进制字符串
     * @param number 要转换的整数（支持非负整数）
     * @param totalLength 十六进制字符串的总长度（不包含0x前缀）
     *                    例如：totalLength=4 表示最终字符串为 0xXXXX 形式
     * @return 带0x前缀的十六进制字符串，不足指定长度时前面补0
     * @throws IllegalArgumentException 如果数字为负数或总长度小于1
     */
    static String toHexString(int number, int totalLength) {
        // 校验输入参数合法性
        if (number < 0) {
            throw new IllegalArgumentException("数字不能为负数：" + number);
        }
        if (totalLength < 1) {
            throw new IllegalArgumentException("总长度必须大于0：" + totalLength);
        }

        // 将数字转换为十六进制字符串（不含前缀，小写）
        String hex = Integer.toHexString(number);

        // 检查是否超过指定长度（超过则直接返回原始十六进制，不截断）
        if (hex.length() > totalLength) {
            return "0x" + hex;
        }

        // 不足指定长度则在前面补0
        StringBuilder paddedHex = new StringBuilder();
        for (int i = 0; i < totalLength - hex.length(); i++) {
            paddedHex.append('0');
        }
        paddedHex.append(hex);

        // 添加0x前缀并返回
        return "0x" + paddedHex.toString();
    }

    /**
     * 批量处理数组，将数组中的数字转换为指定长度的十六进制字符串
     * @param numbers 整数数组（元素需为非负整数）
     * @param totalLength 每个十六进制字符串的总长度（不包含0x前缀）
     * @return 转换后的十六进制字符串数组，与输入数组一一对应
     * @throws IllegalArgumentException 如果数组包含负数或总长度小于1
     */
    static String[] batchToHexStrings(int[] numbers, int totalLength) {
        if (numbers == null) {
            throw new IllegalArgumentException("输入数组不能为null");
        }

        String[] result = new String[numbers.length];
        for (int i = 0; i < numbers.length; i++) {
            result[i] = toHexString(numbers[i], totalLength);
        }
        return result;
    }
    
    
}